17 Bit Software 3: The Continuation/17-Bit_The_Continuation_Disc.iso/amigan/amigan 9/automata/automata.doc

Text File | 1994-01-27 | 5.4 KB | 116 lines

Automata  V1.0   by Mike Dryja  Copyright (C) 1987  All Rights Reserved

DISCLAIMERS AND THINGS OF THAT NATURE

Permission is hereby granted to copy this program for non-profit ventures.
In addition, anyone who would like to include this program on a disk
on which profits will be made must contact me for my approval.  As
of April 13, 1987, permission of this type is granted to the Amigan:
Apprentice and Journeyman, Fred Fish, and Amazing Magazine.  In any case,
this document file MUST be included in its entirity during any sort of
distribution.

If you find this program of any aid to you, I would appreciate a
donation of any amount ($10.00 is suggested).  A donation will put you
on my mailing list for any further programs, and if Automata is updated,
you will receive first notice.  Send any correspondence to:
        Mike Dryja
        5262 Vincent Trail
        Washington, MI  48094

I created this program with the TDI Modula-2 package, and the folks over
there want me to include this line in my software: Developed using TDI
Modula-2/Amiga.  TDI Software Inc.  Dallas, USA.

WHAT IS AUTOMATA?

With that out of the way, let me give you some insight on just what the
Automata program is, and does.  It is based on the Byte article referenced
below.  You might want to think of Automata as the game of Life (you know,
the one where the little dots reproduce, etc), except only in one
dimension.  Each generation in the game of Life takes up a whole screen,
while in one dimension cellular automata (That is the scientific name, by
the way), one generation takes up just one line.  In addition, there are
four different states a cell can be in, represented in this program by
four different colors.

The next generation is determined by the state of the current generation.
This is done by taking a certain cell's state number, adding both of its
neighbors' state numbers, taking this sum and enforcing a rule on it,
then plotting the next generation.  For example, let's say we have the
following automata generation:

    0 1 2 3 1 2 2

Let's also say that the following rule is in effect:

    Sum      : 0 1 2 3 4 5 6 7 8 9
    New Cell : 3 2 1 3 2 0 2 1 3 1

Now, take the cell in the automata generation which has the state number of
3 (the middle one).  The sum of that state number, plus its two neighbors
(2 + 1) equals 6.  Take the sum, 6, and look it up on the table.  Under 6
we find the new cell state is 2.  Therefore, the cell which used to be 3
has now evolved in the next generation as 2.

By using this method, there are a lot of different and exciting possibil-
ities.  By using Automata, you can vary the rule as much as you want.
In my version, there are only four possible states each cell can possess,
0 through 3.  On the screen, 0 is black, 1 is red, 2 is green, and 3 is
blue.  The original rule has been taken from the issue of Byte, and
possesses a very intricate pattern.  Remember when you make your own rule,
that there should be 10 digits (for sums 0 through 9), and the rule can
only have the numbers 0 through 3 in it, as there are no states past 3.
So for example, if you type the rule 0123232011, this means:

    Sum      : 0 1 2 3 4 5 6 7 8 9
    New Cell : 0 1 2 3 2 3 2 0 1 1

Hopefully you now have some idea on just what Automata is.  But this just
scratches the surface, as the field of cellular automata is very complex.
I refer you to the two magazine articles listed below for more study.
Reading them will allow you to have much more enjoyment out of this
program.

BUGS, OMISSIONS, USING THIS MODULE, ETC.

1) As for this version, V1.0, there is just one bug which I could not zap.
When you are entering the rule number, you may get confused with the
scrolling of the rule as you approach the last digit.  I did not want
this to happen, rather I wished for the cursor to remain on the last
digit.  But I couldn't do this for some reason or another.

2) One feature is missing from this program, which may cause some of you
some problems.  I wanted the user to be able to input the original
state, but at this time it is not implemented.  The computer has a
random initial generation, which in itself can be changed by restarting
the program through the menu.

Those are two things I wanted to clear up, and hopefully will in a future
version.

For those of you who want to make your own Automata program, I have the
basic code in a separate library module, AMCalc.  By studying this
module, and how it is interfaced with the other modules, you should be
able to get a pretty good idea of how everything was done.  All I ask is
that if you do use the module, please let me know.  If it is a commercial
venture, remember, this program is copyrighted, so we can discuss
financial concerns.  But if you will be just using it in the public
domain, by all means, go ahead!  When you received this program, hope-
fully all the source files were attached (There are a lot of them!).  If
not, drop me a line, and I'll see if I can get them to you.

REFERENCES

Hapgood, Fred, "Let There Be Life,"  Omni, April 1987, pp. 40-46+.
   This article describes where automata came from, and has an excellent
   introduction on how to make your own rules.  Past that, it describes
   what MIT is doing in this area.

Perry, Kenneth E., "Abstract Mathematical Art,"  Byte, December 1986, pp.
   181-192.
   This article has the main algorithms, and 100 very interesting rules.
   If you just like looking at the automata, get this issue, as the $3.50
   is worth it for the 100 rules alone.